home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’97 / Bugs in My Serial / Bugs in My Serial code / SerialMain.cpp < prev    next >
C/C++ Source or Header  |  1997-06-27  |  4KB  |  222 lines
  1. #include "patches.h"
  2. #include <traps.h>
  3. #include <lowmem.h>
  4. #include "MacsBugSerialStuff.h"
  5. #include "MBPackets.h"
  6. #include <iostream>
  7.  
  8. static MBPacket        gHeader;
  9. static EventRecord    gEvent;
  10. static long            gPos = 0;
  11.  
  12. enum{
  13.     modeHeader = 0,
  14.     modeEvent = 1
  15. };
  16.  
  17. static    long        gMode = modeHeader;
  18.  
  19.  
  20. static asm long*    GetOldDebugUtilStorage()
  21. {
  22.     lea        _oldDebugUtilStorage,a0
  23.     rts
  24. _oldDebugUtilStorage:
  25.     dc.l    0x00000000
  26. }
  27.  
  28. static asm long* GetCountStorage()
  29. {
  30.     lea        _countStorage,a0
  31.     rts
  32. _countStorage:
  33.     dc.l    0x00000000
  34. }
  35.  
  36.  
  37. static asm long* GetValueStorage()
  38. {
  39.     lea        _valueStorage,a0
  40.     rts
  41. _valueStorage:
  42.     dc.l    0x00000000
  43. }
  44.  
  45.  
  46. static asm long* GetA5Storage()
  47. {
  48.     lea        _a5Store,a0
  49.     rts
  50. _a5Store:
  51.     dc.l    0x00000000
  52. }
  53.  
  54.  
  55. static Boolean        KeyIsDown(
  56.     short            theKeyCode)
  57. {
  58.     KeyMap            theKeys;
  59.     
  60.     GetKeys( theKeys);                    /* Get state of each key            */
  61.                                         
  62.         /* Ordering of bits in a KeyMap is truly bizarre. A KeyMap is a    */
  63.         /* 16-byte (128 bits) array where each bit specifies the start    */
  64.         /* of a key (0 = up, 1 = down). We isolate the bit for the        */
  65.         /* specified key code by first determining the byte position in    */
  66.         /* the KeyMap and then the bit position within that byte.        */
  67.         /* Key codes 0-7 are in the first byte (offset 0 from the        */
  68.         /* start), codes 8-15 are in the second, etc. The BitTst() trap    */
  69.         /* counts bits starting from the high-order bit of the byte.    */
  70.         /* For example, for key code 58 (the option key), we look at    */
  71.         /* the 8th byte (7 offset from the first byte) and the 5th bit    */
  72.         /* within that byte.                                            */
  73.         
  74.     return( BitTst( ((char*) &theKeys) + theKeyCode / 8,
  75.                     (long) 7 - (theKeyCode % 8) ) );
  76. }
  77.  
  78. // 16777216
  79.  
  80. static void memset(Ptr p,char value,long length)
  81. {
  82.     long    z = 0;
  83.     for(z = 0;z<length;z++){
  84.         p[z] = value;
  85.     }
  86. }
  87.  
  88. static    Ptr GetScreenBase()
  89. {
  90.     GDHandle        h = LMGetMainDevice();
  91.     
  92.     return h[0]->gdPMap[0]->baseAddr;
  93. }
  94.  
  95. static OSErr        gLastError = 0;
  96.  
  97. static void ReceiveData(long inMBA5)
  98. {
  99.     if(SerialDriver_BytePresent()){
  100.         UInt8    theByte;
  101.         
  102.         if(SerialDriver_ReceiveByte(&theByte,10) == noErr){
  103.             
  104.         
  105.             switch(gMode){
  106.                 case    modeHeader:
  107.                     Ptr        p = (Ptr)&gHeader;
  108.                     p[gPos++] = theByte;
  109.                     if(gPos == sizeof(gHeader)){
  110.                         if(gHeader.magic == kMBMagic){
  111.                             gMode = modeEvent;
  112.                         }
  113.                         
  114.                         gPos = 0;
  115.                     }
  116.                     
  117.                     break;
  118.                     
  119.                 case    modeEvent:
  120.                     // take modifiers you want ROR.W stuff into KeyMap+6
  121.                     
  122.                     Ptr        p1 = (Ptr)&gEvent;
  123.                     p1[gPos++] = theByte;
  124.                     if(gPos == sizeof(gEvent)){
  125.                         
  126.                         short            what = gEvent.what;
  127.                         long            message = gEvent.message;
  128.                         
  129.                         if(what == autoKey){
  130.                             what = keyDown;
  131.                         }
  132.                         
  133.                                 Ptr        p = GetScreenBase();
  134.                                 *p = (*p)?0:0xFF;
  135.                         long            myA5 = SetA5(inMBA5);
  136.                         short            modifiers = gEvent.modifiers;
  137.                         modifiers = modifiers >> 1;
  138.                         short*            keyMap = (short*)(0x174);
  139.                         keyMap[4] = modifiers;
  140.                         
  141.                         OSErr err = PostEvent(what,message);
  142.                         PostEvent(keyUp,0);
  143.                         SetA5(myA5);
  144.                         if(err != noErr){
  145.                             gLastError = err;
  146.                         }
  147.                     //        if(gEvent.what == keyDown){
  148.                     //        }
  149.                     //    }
  150.                         gPos = 0;
  151.                         gMode = modeHeader;
  152.                     }
  153.                     break;
  154.             }
  155.             
  156.         }
  157.     }
  158. }
  159.  
  160.  
  161. static long    Poll(short selector)
  162. {
  163.     long        continueQ = true;
  164.     long*        theA5 = GetA5Storage();
  165.     
  166.     long        mbA5 = SetA5(*theA5);
  167.     
  168.     if(selector == 3){
  169.         ReceiveData(mbA5);
  170.     }
  171.         
  172.     return continueQ;
  173. }
  174.  
  175.  
  176. static asm void newDebugUtil()
  177. {
  178.     subq.l    #4,a7                        // reserve space for old trap address
  179.     move.l    a0,-(a7)                    // save a0
  180.     movem.l    a1-a5/d0-d7,-(a7)            // save everything else
  181.     
  182.     move.w    d0,-(a7)
  183.     jsr        Poll
  184.     addq.l    #2,a7
  185.     tst.w    d0
  186.     bne.s    _Continue
  187.     
  188.     movem.l    (a7)+,a1-a5/d0-d7
  189.     move.l    (a7)+,a0
  190.     addq.l    #4,a7
  191.     rts
  192.     
  193. _Continue:
  194.     
  195.  
  196.     movem.l    (a7)+,a1-a5/d0-d7            // restore registers
  197.     
  198.     jsr        GetOldDebugUtilStorage        // get original trap address storage in a0
  199.     move.l    (a0),a0                        // get original trap address value into a0
  200.     move.l    a0,4(a7)                    // stuff old trap onto stack
  201.     move.l    (a7)+,a0                    // restore original a0
  202.     rts                                    // rts to jump to old trap.
  203. }
  204.  
  205. void main()
  206. {
  207.  
  208.     long*        theA5 = GetA5Storage();
  209.     *theA5 = SetCurrentA5();
  210.  
  211.     long*        debugUtilStorage = GetOldDebugUtilStorage();
  212.     *debugUtilStorage = PatchTrap(_DebugUtil,(long)newDebugUtil);
  213.     
  214.     
  215.     SerialDriver_Open();
  216.     
  217.     Debugger();
  218.     
  219.     cout << "Error: " << gLastError << endl;
  220.     
  221.  
  222. }